home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / news / inn1.000 / inn1.4sec-linux-src.tar / inn / lib / dbz.pch < prev    next >
Text File  |  1993-02-03  |  25KB  |  1,000 lines
  1. DBZ as distributed by CNEWS has a few bits of lint in it.  They fall into
  2. the following categories:
  3.     1.  There is code after return statements, like
  4.         return(value);
  5.         break;
  6.     2.  If you turn off DBZDEBUG some fluff is left behind.
  7.     3.  A couple of (void) casts should be added to fprintf calls
  8.         since ferror is checked right after.
  9.     4.  Use "clibrary.h" for many C library declarations, and the
  10.         POINTER typedef found there.
  11. In addition, DBZ cannot be used with vfork.  (Yes, I agree with all the
  12. other purists that vfork is a crock, but I'm a realist enough to recognize
  13. that it can get some major performance benefits if used in innd.) Applying
  14. this patch makes sure that any files that DBZ opens have the close-on-exec
  15. flag set.
  16.  
  17. This patch also includes two performance enhancements by Rob Robertson
  18. <rob@violet.berkeley.edu>.  The first is the new dbzwritethrough() routine
  19. that makes the incore mode of DBZ use a write-through cache.  The second
  20. is automatic calculation of the database tags; Craig Leres
  21. <leres@ee.lbl.gov> contributed dbztagmask() based on Rob's code.
  22.  
  23. This patch also includes the option to memory-map the database using the
  24. mmap() call.  This original version of that code was by David Robinson,
  25. formerly <david@elroy.jpl.nasa.gov> now <david.robinson@sun.com> (January,
  26. 1993).
  27.  
  28. Apply the following diff by using the "patch" program.  The Makefile
  29. will normally do this for you automatically.
  30.  
  31. DBZ is great, and Jon and Henry (and the others mentioned in the source)
  32. deserve a lot of credit for it.
  33.  
  34. *** ../dbz/dbz.c    Wed Oct 16 10:50:15 1991
  35. --- dbz.c    Fri Jan 22 09:34:06 1993
  36. ***************
  37. *** 12,17 ****
  38. --- 12,24 ----
  39.   
  40.   Major reworking by Henry Spencer as part of the C News project.
  41.   
  42. + Minor lint and CodeCenter (Saber) fluff removal by Rich $alz (March, 1991).
  43. + Non-portable CloseOnExec() calls added by Rich $alz (September, 1991).
  44. + Added "writethrough" and tagmask calculation code from
  45. + <rob@violet.berkeley.edu> and <leres@ee.lbl.gov> by Rich $alz (December, 1992).
  46. + Merged in MMAP code by David Robinson, formerly <david@elroy.jpl.nasa.gov>
  47. + now <david.robinson@sun.com> (January, 1993).
  48. + 
  49.   These routines replace dbm as used by the usenet news software
  50.   (it's not a full dbm replacement by any means).  It's fast and
  51.   simple.  It contains no AT&T code.
  52. ***************
  53. *** 24,30 ****
  54.   
  55.   #include <stdio.h>
  56.   #include <sys/types.h>
  57. ! #include <string.h>
  58.   #include <ctype.h>
  59.   #include <errno.h>
  60.   #ifndef __STDC__
  61. --- 31,37 ----
  62.   
  63.   #include <stdio.h>
  64.   #include <sys/types.h>
  65. ! #include <sys/stat.h>
  66.   #include <ctype.h>
  67.   #include <errno.h>
  68.   #ifndef __STDC__
  69. ***************
  70. *** 31,36 ****
  71. --- 38,44 ----
  72.   extern int errno;
  73.   #endif
  74.   #include <dbz.h>
  75. + #include "clibrary.h"
  76.   
  77.   /*
  78.    * #ifdef index.  "LIA" = "leave it alone unless you know what you're doing".
  79. ***************
  80. *** 50,56 ****
  81. --- 58,67 ----
  82.    * MAXRUN    length of run which shifts to next table (see below) (LIA)
  83.    * OVERFLOW    long-int arithmetic overflow must be avoided, will trap
  84.    * NOBUFFER    do not buffer hash-table i/o, B News locking is defective
  85. +  * MMAP        Use SunOS style mmap() for efficient incore
  86.    */
  87. + /* SUPPRESS 530 *//* Empty body for statement */
  88. + /* SUPPRESS 701 on free *//* Conflicting declaration */
  89.   
  90.   #ifdef FUNNYSEEKS
  91.   #include <unistd.h>
  92. ***************
  93. *** 203,208 ****
  94. --- 214,237 ----
  95.   static void mybytemap();
  96.   static of_t bytemap();
  97.   
  98. + /*
  99. +  * Using mmap() is a more efficent way of keeping the .pag file incore.  On
  100. +  * average, it cuts the number of system calls and buffer copies in half.
  101. +  * It also allows one copy to be shared among many processes without
  102. +  * consuming any extra resources.
  103. +  */
  104. + #ifdef MMAP
  105. + #include <sys/mman.h>
  106. + #ifdef MAP_FILE
  107. + #define MAP__ARG    (MAP_FILE | MAP_SHARED)
  108. + #else
  109. + #define MAP__ARG    (MAP_SHARED)
  110. + #endif
  111. + #ifndef INCORE
  112. + #define INCORE
  113. + #endif
  114. + #endif
  115. + 
  116.   /* 
  117.    * For a program that makes many, many references to the database, it
  118.    * is a large performance win to keep the table in core, if it will fit.
  119. ***************
  120. *** 228,233 ****
  121. --- 257,270 ----
  122.   #endif
  123.   
  124.   /*
  125. +  * Write to filesystem even if incore?  This replaces a single multi-
  126. +  * megabyte write when doing a dbzsync with a multi-byte write each
  127. +  * time an article is added.  On most systems, this will give an overall
  128. +  * performance boost.
  129. +  */
  130. + static int writethrough = 0;
  131. + 
  132. + /*
  133.    * Stdio buffer for .pag reads.  Buffering more than about 16 does not help
  134.    * significantly at the densities we try to maintain, and the much larger
  135.    * buffers that most stdios default to are much more expensive to fill.
  136. ***************
  137. *** 298,316 ****
  138.    * alternative (under most compilers) is to pack around 2K of unused
  139.    * strings -- there's just no way to get rid of them.
  140.    */
  141. - static int debug;            /* controlled by dbzdebug() */
  142.   #ifdef DBZDEBUG
  143. ! #define DEBUG(args) if (debug) { (void) printf args ; }
  144.   #else
  145.   #define    DEBUG(args)    ;
  146.   #endif
  147.   
  148.   /* externals used */
  149.   extern char *malloc();
  150.   extern char *calloc();
  151.   extern void free();        /* ANSI C; some old implementations say int */
  152.   extern int atoi();
  153.   extern long atol();
  154.   
  155.   /* misc. forwards */
  156.   static long hash();
  157. --- 335,358 ----
  158.    * alternative (under most compilers) is to pack around 2K of unused
  159.    * strings -- there's just no way to get rid of them.
  160.    */
  161.   #ifdef DBZDEBUG
  162. ! static int debug;            /* controlled by dbzdebug() */
  163. ! #define DEBUG(args) if (debug) { (void) printf args ; } else
  164.   #else
  165.   #define    DEBUG(args)    ;
  166.   #endif
  167.   
  168.   /* externals used */
  169. + #if    0
  170. + extern char *memcpy();
  171. + extern char *memchr();
  172.   extern char *malloc();
  173.   extern char *calloc();
  174.   extern void free();        /* ANSI C; some old implementations say int */
  175. + #endif    /* 0 */
  176.   extern int atoi();
  177.   extern long atol();
  178. + extern void CloseOnExec();
  179.   
  180.   /* misc. forwards */
  181.   static long hash();
  182. ***************
  183. *** 336,342 ****
  184. --- 378,386 ----
  185.   static of_t *corepag;        /* incore version of .pag file, if any */
  186.   static FILE *bufpagf;        /* well-buffered pagf, for incore rewrite */
  187.   static of_t *getcore();
  188. + #ifndef MMAP
  189.   static int putcore();
  190. + #endif
  191.   static int written;        /* has a store() been done? */
  192.   
  193.   /*
  194. ***************
  195. *** 391,399 ****
  196.       default:
  197.           DEBUG(("dbzfresh case map `%c' unknown\n", cmap));
  198.           return(-1);
  199. -         break;
  200.       }
  201. !     switch (tagmask) {
  202.       case 0:            /* default */
  203.           break;
  204.       case 1:            /* no tags */
  205. --- 435,442 ----
  206.       default:
  207.           DEBUG(("dbzfresh case map `%c' unknown\n", cmap));
  208.           return(-1);
  209.       }
  210. !     switch ((int)tagmask) {
  211.       case 0:            /* default */
  212.           break;
  213.       case 1:            /* no tags */
  214. ***************
  215. *** 418,424 ****
  216.       if (fn == NULL)
  217.           return(-1);
  218.       f = fopen(fn, "w");
  219. !     free(fn);
  220.       if (f == NULL) {
  221.           DEBUG(("dbzfresh: unable to write config\n"));
  222.           return(-1);
  223. --- 461,467 ----
  224.       if (fn == NULL)
  225.           return(-1);
  226.       f = fopen(fn, "w");
  227. !     free((POINTER)fn);
  228.       if (f == NULL) {
  229.           DEBUG(("dbzfresh: unable to write config\n"));
  230.           return(-1);
  231. ***************
  232. *** 437,443 ****
  233.       if (fn == NULL)
  234.           return(-1);
  235.       f = fopen(fn, "w");
  236. !     free(fn);
  237.       if (f == NULL) {
  238.           DEBUG(("dbzfresh: unable to create/truncate .pag file\n"));
  239.           return(-1);
  240. --- 480,486 ----
  241.       if (fn == NULL)
  242.           return(-1);
  243.       f = fopen(fn, "w");
  244. !     free((POINTER)fn);
  245.       if (f == NULL) {
  246.           DEBUG(("dbzfresh: unable to create/truncate .pag file\n"));
  247.           return(-1);
  248. ***************
  249. *** 522,527 ****
  250. --- 565,572 ----
  251.       register FILE *f;
  252.       register int newtable;
  253.       register of_t newsize;
  254. +     struct stat sb;
  255. +     register of_t m;
  256.   
  257.       if (pagf != NULL) {
  258.           DEBUG(("dbzagain: database already open\n"));
  259. ***************
  260. *** 533,539 ****
  261.       if (fn == NULL)
  262.           return(-1);
  263.       f = fopen(fn, "r");
  264. !     free(fn);
  265.       if (f == NULL) {
  266.           DEBUG(("dbzagain: cannot open old .dir file\n"));
  267.           return(-1);
  268. --- 578,584 ----
  269.       if (fn == NULL)
  270.           return(-1);
  271.       f = fopen(fn, "r");
  272. !     free((POINTER)fn);
  273.       if (f == NULL) {
  274.           DEBUG(("dbzagain: cannot open old .dir file\n"));
  275.           return(-1);
  276. ***************
  277. *** 545,550 ****
  278. --- 590,608 ----
  279.           return(-1);
  280.       }
  281.   
  282. +     /* calculate tagging from old file */
  283. +     if (stat(oldname, &sb) != -1) {
  284. +          for (m = 1, i = 0; m < sb.st_size; i++, m <<= 1)
  285. +              continue;
  286. +          
  287. +          /* if we had more tags than the default, use the new data */
  288. +          if ((c.tagmask | c.tagenb) && m > (1 << TAGSHIFT)) {
  289. +               c.tagshift = i;
  290. +               c.tagmask = (~(unsigned long)0) >> (i + 1);
  291. +               c.tagenb = (c.tagmask << 1) & ~c.tagmask;
  292. +          }
  293. +     }
  294. + 
  295.       /* tinker with it */
  296.       top = 0;
  297.       newtable = 0;
  298. ***************
  299. *** 570,576 ****
  300.       if (fn == NULL)
  301.           return(-1);
  302.       f = fopen(fn, "w");
  303. !     free(fn);
  304.       if (f == NULL) {
  305.           DEBUG(("dbzagain: unable to write new .dir\n"));
  306.           return(-1);
  307. --- 628,634 ----
  308.       if (fn == NULL)
  309.           return(-1);
  310.       f = fopen(fn, "w");
  311. !     free((POINTER)fn);
  312.       if (f == NULL) {
  313.           DEBUG(("dbzagain: unable to write new .dir\n"));
  314.           return(-1);
  315. ***************
  316. *** 587,593 ****
  317.       if (fn == NULL)
  318.           return(-1);
  319.       f = fopen(fn, "w");
  320. !     free(fn);
  321.       if (f == NULL) {
  322.           DEBUG(("dbzagain: unable to create/truncate .pag file\n"));
  323.           return(-1);
  324. --- 645,651 ----
  325.       if (fn == NULL)
  326.           return(-1);
  327.       f = fopen(fn, "w");
  328. !     free((POINTER)fn);
  329.       if (f == NULL) {
  330.           DEBUG(("dbzagain: unable to create/truncate .pag file\n"));
  331.           return(-1);
  332. ***************
  333. *** 629,639 ****
  334.           dirronly = 1;
  335.       } else
  336.           dirronly = 0;
  337. !     free(dirfname);
  338.       if (dirf == NULL) {
  339.           DEBUG(("dbminit: can't open .dir file\n"));
  340.           return(-1);
  341.       }
  342.   
  343.       /* open the .pag file */
  344.       pagfname = enstring(name, pag);
  345. --- 687,698 ----
  346.           dirronly = 1;
  347.       } else
  348.           dirronly = 0;
  349. !     free((POINTER)dirfname);
  350.       if (dirf == NULL) {
  351.           DEBUG(("dbminit: can't open .dir file\n"));
  352.           return(-1);
  353.       }
  354. +     CloseOnExec((int)fileno(dirf), 1);
  355.   
  356.       /* open the .pag file */
  357.       pagfname = enstring(name, pag);
  358. ***************
  359. *** 647,653 ****
  360.           if (pagf == NULL) {
  361.               DEBUG(("dbminit: .pag open failed\n"));
  362.               (void) fclose(dirf);
  363. !             free(pagfname);
  364.               return(-1);
  365.           }
  366.           pagronly = 1;
  367. --- 706,712 ----
  368.           if (pagf == NULL) {
  369.               DEBUG(("dbminit: .pag open failed\n"));
  370.               (void) fclose(dirf);
  371. !             free((POINTER)pagfname);
  372.               return(-1);
  373.           }
  374.           pagronly = 1;
  375. ***************
  376. *** 655,660 ****
  377. --- 714,721 ----
  378.           pagronly = 1;
  379.       else
  380.           pagronly = 0;
  381. +     if (pagf != NULL)
  382. +         CloseOnExec((int)fileno(pagf), 1);
  383.   #ifdef NOBUFFER
  384.       /*
  385.        * B News does not do adequate locking on its database accesses.
  386. ***************
  387. *** 679,690 ****
  388.           if (basefname == NULL) {
  389.               (void) fclose(pagf);
  390.               (void) fclose(dirf);
  391. !             free(pagfname);
  392.               pagf = NULL;
  393.               return(-1);
  394.           }
  395.       } else
  396.           basefname = NULL;
  397.   #ifdef _IOFBF
  398.       if (basef != NULL)
  399.           (void) setvbuf(basef, basebuf, _IOFBF, sizeof(basebuf));
  400. --- 740,753 ----
  401.           if (basefname == NULL) {
  402.               (void) fclose(pagf);
  403.               (void) fclose(dirf);
  404. !             free((POINTER)pagfname);
  405.               pagf = NULL;
  406.               return(-1);
  407.           }
  408.       } else
  409.           basefname = NULL;
  410. +     if (basef != NULL)
  411. +         CloseOnExec((int)fileno(basef), 1);
  412.   #ifdef _IOFBF
  413.       if (basef != NULL)
  414.           (void) setvbuf(basef, basebuf, _IOFBF, sizeof(basebuf));
  415. ***************
  416. *** 696,702 ****
  417.           (void) fclose(basef);
  418.           (void) fclose(pagf);
  419.           (void) fclose(dirf);
  420. !         free(pagfname);
  421.           pagf = NULL;
  422.           errno = EDOM;    /* kind of a kludge, but very portable */
  423.           return(-1);
  424. --- 759,765 ----
  425.           (void) fclose(basef);
  426.           (void) fclose(pagf);
  427.           (void) fclose(dirf);
  428. !         free((POINTER)pagfname);
  429.           pagf = NULL;
  430.           errno = EDOM;    /* kind of a kludge, but very portable */
  431.           return(-1);
  432. ***************
  433. *** 714,726 ****
  434.       s = (size_t)conf.tsize * SOF;
  435.       if (incore && (of_t)(s/SOF) == conf.tsize) {
  436.           bufpagf = fopen(pagfname, (pagronly) ? "rb" : "r+b");
  437. !         if (bufpagf != NULL)
  438.               corepag = getcore(bufpagf);
  439.       } else {
  440.           bufpagf = NULL;
  441.           corepag = NULL;
  442.       }
  443. !     free(pagfname);
  444.   
  445.       /* misc. setup */
  446.       crcinit();
  447. --- 777,791 ----
  448.       s = (size_t)conf.tsize * SOF;
  449.       if (incore && (of_t)(s/SOF) == conf.tsize) {
  450.           bufpagf = fopen(pagfname, (pagronly) ? "rb" : "r+b");
  451. !         if (bufpagf != NULL) {
  452.               corepag = getcore(bufpagf);
  453. +             CloseOnExec((int)fileno(bufpagf), 1);
  454. +         }
  455.       } else {
  456.           bufpagf = NULL;
  457.           corepag = NULL;
  458.       }
  459. !     free((POINTER)pagfname);
  460.   
  461.       /* misc. setup */
  462.       crcinit();
  463. ***************
  464. *** 775,781 ****
  465.           ret = -1;
  466.       }
  467.       if (corepag != NULL)
  468. !         free((char *)corepag);
  469.       corepag = NULL;
  470.       if (fclose(basef) == EOF) {
  471.           DEBUG(("dbmclose: fclose(basef) failed\n"));
  472. --- 840,853 ----
  473.           ret = -1;
  474.       }
  475.       if (corepag != NULL)
  476. ! #ifdef MMAP
  477. !         if (munmap(corepag, (int)conf.tsize * SOF) == -1) {
  478. !             DEBUG(("dbmclose: munmap failed\n"));
  479. !             ret = -1;
  480. !         }
  481. ! #else
  482. !         free((POINTER)corepag);
  483. ! #endif
  484.       corepag = NULL;
  485.       if (fclose(basef) == EOF) {
  486.           DEBUG(("dbmclose: fclose(basef) failed\n"));
  487. ***************
  488. *** 782,788 ****
  489.           ret = -1;
  490.       }
  491.       if (basefname != NULL)
  492. !         free(basefname);
  493.       basef = NULL;
  494.       pagf = NULL;
  495.       if (fclose(dirf) == EOF) {
  496. --- 854,860 ----
  497.           ret = -1;
  498.       }
  499.       if (basefname != NULL)
  500. !         free((POINTER)basefname);
  501.       basef = NULL;
  502.       pagf = NULL;
  503.       if (fclose(dirf) == EOF) {
  504. ***************
  505. *** 809,820 ****
  506.       if (!written)
  507.           return(0);
  508.   
  509. !     if (corepag != NULL) {
  510.           if (putcore(corepag, bufpagf) < 0) {
  511.               DEBUG(("dbzsync: putcore failed\n"));
  512.               ret = -1;
  513.           }
  514.       }
  515.       if (!conf.olddbz)
  516.           if (putconf(dirf, &conf) < 0)
  517.               ret = -1;
  518. --- 881,894 ----
  519.       if (!written)
  520.           return(0);
  521.   
  522. ! #ifndef MMAP
  523. !     if (corepag != NULL && !writethrough) {
  524.           if (putcore(corepag, bufpagf) < 0) {
  525.               DEBUG(("dbzsync: putcore failed\n"));
  526.               ret = -1;
  527.           }
  528.       }
  529. + #endif
  530.       if (!conf.olddbz)
  531.           if (putconf(dirf, &conf) < 0)
  532.               ret = -1;
  533. ***************
  534. *** 922,928 ****
  535.               DEBUG(("fetch: seek failed\n"));
  536.               return(output);
  537.           }
  538. !         if (fread(buffer, 1, keysize, basef) != keysize) {
  539.               DEBUG(("fetch: read failed\n"));
  540.               return(output);
  541.           }
  542. --- 996,1002 ----
  543.               DEBUG(("fetch: seek failed\n"));
  544.               return(output);
  545.           }
  546. !         if (fread((POINTER)buffer, 1, keysize, basef) != keysize) {
  547.               DEBUG(("fetch: read failed\n"));
  548.               return(output);
  549.           }
  550. ***************
  551. *** 932,938 ****
  552.           (void) mapcase(buffer, buffer, keysize);
  553.           DEBUG(("fetch: buffer (%s) looking for (%s) size = %d\n", 
  554.                           buffer, key.dptr, keysize));
  555. !         if (memcmp(key.dptr, buffer, cmplen) == 0 &&
  556.                   (*sepp == conf.fieldsep || *sepp == '\0')) {
  557.               /* we found it */
  558.               output.dptr = (char *)&key_ptr;
  559. --- 1006,1012 ----
  560.           (void) mapcase(buffer, buffer, keysize);
  561.           DEBUG(("fetch: buffer (%s) looking for (%s) size = %d\n", 
  562.                           buffer, key.dptr, keysize));
  563. !         if (memcmp((POINTER)key.dptr, (POINTER)buffer, cmplen) == 0 &&
  564.                   (*sepp == conf.fieldsep || *sepp == '\0')) {
  565.               /* we found it */
  566.               output.dptr = (char *)&key_ptr;
  567. ***************
  568. *** 965,976 ****
  569.           DEBUG(("latebase: still can't open base\n"));
  570.       } else {
  571.           DEBUG(("latebase: late open succeeded\n"));
  572. !         free(basefname);
  573.           basefname = NULL;
  574.   #ifdef _IOFBF
  575.           (void) setvbuf(it, basebuf, _IOFBF, sizeof(basebuf));
  576.   #endif
  577.       }
  578.       return(it);
  579.   }
  580.   
  581. --- 1039,1052 ----
  582.           DEBUG(("latebase: still can't open base\n"));
  583.       } else {
  584.           DEBUG(("latebase: late open succeeded\n"));
  585. !         free((POINTER)basefname);
  586.           basefname = NULL;
  587.   #ifdef _IOFBF
  588.           (void) setvbuf(it, basebuf, _IOFBF, sizeof(basebuf));
  589.   #endif
  590.       }
  591. +     if (it != NULL)
  592. +         CloseOnExec((int)fileno(it), 1);
  593.       return(it);
  594.   }
  595.   
  596. ***************
  597. *** 1034,1040 ****
  598.       }
  599.   
  600.       /* copy the value in to ensure alignment */
  601. !     (void) memcpy((char *)&value, data.dptr, SOF);
  602.       DEBUG(("store: (%s, %ld)\n", key.dptr, (long)value));
  603.       if (!okayvalue(value)) {
  604.           DEBUG(("store: reserved bit or overflow in 0x%lx\n", value));
  605. --- 1110,1116 ----
  606.       }
  607.   
  608.       /* copy the value in to ensure alignment */
  609. !     (void) memcpy((POINTER)&value, (POINTER)data.dptr, SOF);
  610.       DEBUG(("store: (%s, %ld)\n", key.dptr, (long)value));
  611.       if (!okayvalue(value)) {
  612.           DEBUG(("store: reserved bit or overflow in 0x%lx\n", value));
  613. ***************
  614. *** 1062,1072 ****
  615. --- 1138,1188 ----
  616.   {
  617.       register int old = incore;
  618.   
  619. + #ifndef MMAP
  620.       incore = value;
  621. + #endif
  622.       return(old);
  623.   }
  624.   
  625.   /*
  626. +  - dbzwritethrough - write through the pag file in core
  627. +  */
  628. + int                /* old setting */
  629. + dbzwritethrough(value)
  630. + int value;
  631. + {
  632. +     register int old = writethrough;
  633. + 
  634. +     writethrough = value;
  635. +     return(old);
  636. + }
  637. + 
  638. + /*
  639. +  - dbztagmask - calculate the correct tagmask for the given base file size
  640. +  */
  641. + long
  642. + dbztagmask(size)
  643. + register long size;
  644. + {
  645. +     register long m;
  646. +     register long tagmask;
  647. +     register int i;
  648. + 
  649. +     if (size <= 0)
  650. +         return(0L);        /* silly size */
  651. + 
  652. +     for (m = 1, i = 0; m < size; i++, m <<= 1)
  653. +         continue;
  654. + 
  655. +     if (m < (1 << TAGSHIFT))
  656. +         return(0L);        /* not worth tagging */
  657. + 
  658. +     tagmask = (~(unsigned long)0) >> (i + 1);
  659. +     tagmask = tagmask << i;
  660. +     return(tagmask);
  661. + }
  662. + 
  663. + /*
  664.    - getconf - get configuration from .dir file
  665.    */
  666.   static int            /* 0 success, -1 failure */
  667. ***************
  668. *** 1107,1113 ****
  669.       if (getno(df, &err) != dbzversion)
  670.           err = -1;
  671.       cp->tsize = getno(df, &err);
  672. !     cp->fieldsep = getno(df, &err);
  673.       while ((c = getc(df)) == ' ')
  674.           continue;
  675.       cp->casemap = c;
  676. --- 1223,1229 ----
  677.       if (getno(df, &err) != dbzversion)
  678.           err = -1;
  679.       cp->tsize = getno(df, &err);
  680. !     cp->fieldsep = (int)getno(df, &err);
  681.       while ((c = getc(df)) == ' ')
  682.           continue;
  683.       cp->casemap = c;
  684. ***************
  685. *** 1124,1129 ****
  686. --- 1240,1246 ----
  687.           cp->bytemap[i] = getno(df, &err);
  688.       if (getc(df) != '\n')
  689.           err = -1;
  690. + #ifdef DBZDEBUG
  691.       DEBUG(("size %ld, sep %d, cmap %c, tags 0x%lx/0x%lx<<%d, ", cp->tsize,
  692.               cp->fieldsep, cp->casemap, cp->tagenb, cp->tagmask,
  693.               cp->tagshift));
  694. ***************
  695. *** 1132,1137 ****
  696. --- 1249,1255 ----
  697.           DEBUG((" %d", cp->bytemap[i]));
  698.       }
  699.       DEBUG(("\n"));
  700. + #endif
  701.   
  702.       /* second line, the usages */
  703.       for (i = 0; i < NUSEDS; i++)
  704. ***************
  705. *** 1201,1214 ****
  706.           DEBUG(("fseek failure in putconf\n"));
  707.           ret = -1;
  708.       }
  709. !     fprintf(f, "dbz %d %ld %d %c %ld %ld %d %d", dbzversion, cp->tsize,
  710.                   cp->fieldsep, cp->casemap, cp->tagenb,
  711.                   cp->tagmask, cp->tagshift, cp->valuesize);
  712.       for (i = 0; i < cp->valuesize; i++)
  713. !         fprintf(f, " %d", cp->bytemap[i]);
  714. !     fprintf(f, "\n");
  715.       for (i = 0; i < NUSEDS; i++)
  716. !         fprintf(f, "%ld%c", cp->used[i], (i < NUSEDS-1) ? ' ' : '\n');
  717.   
  718.       (void) fflush(f);
  719.       if (ferror(f))
  720. --- 1319,1332 ----
  721.           DEBUG(("fseek failure in putconf\n"));
  722.           ret = -1;
  723.       }
  724. !     (void) fprintf(f, "dbz %d %ld %d %c %ld %ld %d %d", dbzversion, cp->tsize,
  725.                   cp->fieldsep, cp->casemap, cp->tagenb,
  726.                   cp->tagmask, cp->tagshift, cp->valuesize);
  727.       for (i = 0; i < cp->valuesize; i++)
  728. !         (void) fprintf(f, " %d", cp->bytemap[i]);
  729. !     (void) fprintf(f, "\n");
  730.       for (i = 0; i < NUSEDS; i++)
  731. !         (void) fprintf(f, "%ld%c", cp->used[i], (i < NUSEDS-1) ? ' ' : '\n');
  732.   
  733.       (void) fflush(f);
  734.       if (ferror(f))
  735. ***************
  736. *** 1229,1235 ****
  737. --- 1347,1378 ----
  738.       register size_t i;
  739.       register size_t nread;
  740.       register char *it;
  741. + #ifdef MMAP
  742. +     struct stat st;
  743.   
  744. +     if (fstat(fileno(f), &st) == -1) {
  745. +         DEBUG(("getcore: fstat failed\n"));
  746. +         return(NULL);
  747. +     }
  748. +     if (((size_t)conf.tsize * SOF) > st.st_size) {
  749. +         /* file too small; extend it */
  750. +         if (ftruncate((int)fileno(f), conf.tsize * SOF) == -1) {
  751. +             DEBUG(("getcore: ftruncate failed\n"));
  752. +             return(NULL);
  753. +         }
  754. +     }
  755. +     it = mmap((caddr_t)0, (size_t)conf.tsize * SOF, 
  756. +         pagronly ? PROT_READ : PROT_WRITE | PROT_READ, MAP__ARG,
  757. +         (int)fileno(f), (off_t)0);
  758. +     if (it == (char *)-1) {
  759. +         DEBUG(("getcore: mmap failed\n"));
  760. +         return(NULL);
  761. +     }
  762. + #ifdef MC_ADVISE
  763. +     /* not present in all versions of mmap() */
  764. +     madvise(it, (size_t)conf.tsize * SOF, MADV_RANDOM);
  765. + #endif
  766. + #else
  767.       it = malloc((size_t)conf.tsize * SOF);
  768.       if (it == NULL) {
  769.           DEBUG(("getcore: malloc failed\n"));
  770. ***************
  771. *** 1236,1255 ****
  772.           return(NULL);
  773.       }
  774.   
  775. !     nread = fread(it, SOF, (size_t)conf.tsize, f);
  776.       if (ferror(f)) {
  777.           DEBUG(("getcore: read failed\n"));
  778. !         free(it);
  779.           return(NULL);
  780.       }
  781.   
  782.       p = (of_t *)it + nread;
  783.       i = (size_t)conf.tsize - nread;
  784.       while (i-- > 0)
  785.           *p++ = VACANT;
  786.       return((of_t *)it);
  787.   }
  788.   
  789.   /*
  790.    - putcore - try to rewrite an in-core table
  791.    */
  792. --- 1379,1402 ----
  793.           return(NULL);
  794.       }
  795.   
  796. !     nread = fread((POINTER)it, SOF, (size_t)conf.tsize, f);
  797.       if (ferror(f)) {
  798.           DEBUG(("getcore: read failed\n"));
  799. !         free((POINTER)it);
  800.           return(NULL);
  801.       }
  802.   
  803. +      /* NOSTRICT *//* Possible pointer alignment problem */
  804.       p = (of_t *)it + nread;
  805.       i = (size_t)conf.tsize - nread;
  806.       while (i-- > 0)
  807.           *p++ = VACANT;
  808. + #endif
  809. +      /* NOSTRICT *//* Possible pointer alignment problem */
  810.       return((of_t *)it);
  811.   }
  812.   
  813. + #ifndef MMAP
  814.   /*
  815.    - putcore - try to rewrite an in-core table
  816.    */
  817. ***************
  818. *** 1262,1271 ****
  819.           DEBUG(("fseek failure in putcore\n"));
  820.           return(-1);
  821.       }
  822. !     (void) fwrite((char *)tab, SOF, (size_t)conf.tsize, f);
  823.       (void) fflush(f);
  824.       return((ferror(f)) ? -1 : 0);
  825.   }
  826.   
  827.   /*
  828.    - start - set up to start or restart a search
  829. --- 1409,1419 ----
  830.           DEBUG(("fseek failure in putcore\n"));
  831.           return(-1);
  832.       }
  833. !     (void) fwrite((POINTER)tab, SOF, (size_t)conf.tsize, f);
  834.       (void) fflush(f);
  835.       return((ferror(f)) ? -1 : 0);
  836.   }
  837. + #endif
  838.   
  839.   /*
  840.    - start - set up to start or restart a search
  841. ***************
  842. *** 1343,1349 ****
  843.               }
  844.   
  845.               /* read it */
  846. !             if (fread((char *)&val, sizeof(val), 1, pagf) == 1)
  847.                   value = MAPIN(val);
  848.               else if (ferror(pagf)) {
  849.                   DEBUG(("search: read failed\n"));
  850. --- 1491,1497 ----
  851.               }
  852.   
  853.               /* read it */
  854. !             if (fread((POINTER)&val, sizeof(val), 1, pagf) == 1)
  855.                   value = MAPIN(val);
  856.               else if (ferror(pagf)) {
  857.                   DEBUG(("search: read failed\n"));
  858. ***************
  859. *** 1425,1436 ****
  860.       if (corepag != NULL && place < conf.tsize) {
  861.           corepag[place] = value;
  862.           DEBUG(("set: incore\n"));
  863.           return(0);
  864.       }
  865.   
  866.       /* seek to spot */
  867.       pagpos = -1;        /* invalidate position memory */
  868. !     if (fseek(pagf, place * SOF, SEEK_SET) != 0) {
  869.           DEBUG(("set: seek failed\n"));
  870.           sp->aborted = 1;
  871.           return(-1);
  872. --- 1573,1589 ----
  873.       if (corepag != NULL && place < conf.tsize) {
  874.           corepag[place] = value;
  875.           DEBUG(("set: incore\n"));
  876. + #ifdef MMAP
  877.           return(0);
  878. + #else
  879. +         if (!writethrough)
  880. +             return(0);
  881. + #endif
  882.       }
  883.   
  884.       /* seek to spot */
  885.       pagpos = -1;        /* invalidate position memory */
  886. !     if (fseek(pagf, (of_t)(place * SOF), SEEK_SET) != 0) {
  887.           DEBUG(("set: seek failed\n"));
  888.           sp->aborted = 1;
  889.           return(-1);
  890. ***************
  891. *** 1437,1443 ****
  892.       }
  893.   
  894.       /* write in data */
  895. !     if (fwrite((char *)&value, SOF, 1, pagf) != 1) {
  896.           DEBUG(("set: write failed\n"));
  897.           sp->aborted = 1;
  898.           return(-1);
  899. --- 1590,1596 ----
  900.       }
  901.   
  902.       /* write in data */
  903. !     if (fwrite((POINTER)&value, SOF, 1, pagf) != 1) {
  904.           DEBUG(("set: write failed\n"));
  905.           sp->aborted = 1;
  906.           return(-1);
  907. ***************
  908. *** 1474,1479 ****
  909. --- 1627,1633 ----
  910.       u.o = 1;
  911.       for (ntodo = (int)SOF; ntodo > 0; ntodo--) {
  912.           for (i = 0; i < SOF; i++)
  913. +             /* SUPPRESS 112 *//* Retrieving char where long is stored */
  914.               if (u.c[i] != 0)
  915.                   break;
  916.           if (i == SOF) {
  917. ***************
  918. *** 1485,1490 ****
  919. --- 1639,1645 ----
  920.           }
  921.           DEBUG(("mybytemap: byte %d\n", i));
  922.           *--mp = i;
  923. +         /* SUPPRESS 112 *//* Retrieving char where long is stored */
  924.           while (u.c[i] != 0)
  925.               u.o <<= 1;
  926.       }
  927. ***************
  928. *** 1728,1747 ****
  929.       switch (conf.casemap) {
  930.       case '0':        /* unmapped, sensible */
  931.           return(NULL);
  932. -         break;
  933.       case 'C':        /* C News, RFC 822 conformant (approx.) */
  934. !         p = memchr(s, '@', siz);
  935.           if (p == NULL)            /* no local/domain split */
  936.               return(NULL);        /* assume all local */
  937. !         else if    (p - (s+1) == plen && CISTREQN(s+1, post, plen)) {
  938.               /* crazy -- "postmaster" is case-insensitive */
  939.               return(s);
  940. !         } else
  941. !             return(p);
  942. !         break;
  943.       case '=':        /* 2.11, neither sensible nor conformant */
  944.           return(s);    /* all case-insensitive */
  945. -         break;
  946.       }
  947.   
  948.       DEBUG(("cipoint: unknown case mapping `%c'\n", conf.casemap));
  949. --- 1883,1899 ----
  950.       switch (conf.casemap) {
  951.       case '0':        /* unmapped, sensible */
  952.           return(NULL);
  953.       case 'C':        /* C News, RFC 822 conformant (approx.) */
  954. !         p = memchr((POINTER)s, '@', siz);
  955.           if (p == NULL)            /* no local/domain split */
  956.               return(NULL);        /* assume all local */
  957. !         if (p - (s+1) == plen && CISTREQN(s+1, post, plen)) {
  958.               /* crazy -- "postmaster" is case-insensitive */
  959.               return(s);
  960. !         }
  961. !         return(p);
  962.       case '=':        /* 2.11, neither sensible nor conformant */
  963.           return(s);    /* all case-insensitive */
  964.       }
  965.   
  966.       DEBUG(("cipoint: unknown case mapping `%c'\n", conf.casemap));
  967. ***************
  968. *** 1751,1766 ****
  969.   /*
  970.    - dbzdebug - control dbz debugging at run time
  971.    */
  972.   int                /* old value */
  973.   dbzdebug(value)
  974.   int value;
  975.   {
  976. - #ifdef DBZDEBUG
  977.       register int old = debug;
  978.   
  979.       debug = value;
  980.       return(old);
  981. - #else
  982. -     return(-1);
  983. - #endif
  984.   }
  985. --- 1903,1916 ----
  986.   /*
  987.    - dbzdebug - control dbz debugging at run time
  988.    */
  989. + #ifdef DBZDEBUG
  990.   int                /* old value */
  991.   dbzdebug(value)
  992.   int value;
  993.   {
  994.       register int old = debug;
  995.   
  996.       debug = value;
  997.       return(old);
  998.   }
  999. + #endif
  1000.